package com.punai.common.utils;

import org.apache.commons.lang3.math.NumberUtils;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.List;

/**
 * 说明：NumberUtil数字工具类
 * 
 * @Title: NumberUtil.java
 * @Package com.punai.core.util.lang
 * @See: {@link NumberUtils} Copyright: Copyright (c) 2016 Company:punai team by
 *       product
 * @author: fuyp
 * @date: 2017年6月12日 下午2:11:46
 * @version: V1.0
 */
public abstract class NumberUtil extends NumberUtils {
	//--------statr--------------//
	
	/**
     * 中文数字
     */
    private static final String[] CN_NUM = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};

    /**
     * 中文数字单位
     */
    private static final String[] CN_UNIT = {"", "十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千"};

    /**
     * 特殊字符：负
     */
    private static final String CN_NEGATIVE = "负";

    /**
     * 特殊字符：点
     */
    private static final String CN_POINT = "点";
	
    /**
     * int 转 中文数字
     * 支持到int最大值
     * 
     * @param intNum 要转换的整型数
     * @return 中文数字
     */
    public static String int2chineseNum(int intNum) {
        StringBuffer sb = new StringBuffer();
        boolean isNegative = false;
        if (intNum < 0) {
            isNegative = true;
            intNum *= -1;
        }
        int count = 0;
        while(intNum > 0) {
            sb.insert(0, CN_NUM[intNum % 10] + CN_UNIT[count]);
            intNum = intNum / 10;
            count++;
        }

        if (isNegative)
            sb.insert(0, CN_NEGATIVE);


        return sb.toString().replaceAll("零[千百十]", "零").replaceAll("零+万", "万")
                .replaceAll("零+亿", "亿").replaceAll("亿万", "亿零")
                .replaceAll("零+", "零").replaceAll("零$", "");
    }

	public static BigDecimal divide(BigDecimal valueOne, int position, int roundingMode,BigDecimal valueTwo) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo || 0 == NumberUtil.compareTo(valueTwo, NumberUtil.getValue(0))) {
			return ZERO_VALUE;
		}
		return valueOne.divide(valueTwo, position, roundingMode);
	}

    /**
     * bigDecimal 转 中文数字
     * 整数部分只支持到int的最大值
     * 
     * @param bigDecimalNum 要转换的BigDecimal数
     * @return 中文数字
     */
    public static String bigDecimal2chineseNum(BigDecimal bigDecimalNum) {
        if (bigDecimalNum == null)
            return CN_NUM[0];

        StringBuffer sb = new StringBuffer();

        //将小数点后面的零给去除
        String numStr = bigDecimalNum.abs().stripTrailingZeros().toPlainString();

        String[] split = numStr.split("\\.");
        String integerStr = int2chineseNum(Integer.parseInt(split[0]));

        sb.append(integerStr);

        //如果传入的数有小数，则进行切割，将整数与小数部分分离
        if (split.length == 2) {
            //有小数部分
            sb.append(CN_POINT);
            String decimalStr = split[1];
            char[] chars = decimalStr.toCharArray();
            for (int i = 0; i < chars.length; i++) {
                int index = Integer.parseInt(String.valueOf(chars[i]));
                sb.append(CN_NUM[index]);
            }
        }

        //判断传入数字为正数还是负数
        int signum = bigDecimalNum.signum();
        if (signum == -1) {
            sb.insert(0, CN_NEGATIVE);
        }

        return sb.toString();
    }
    //--------end--------------
	/**
	 * 说明：objectToInteger
	 * 
	 * @Title: objectToInteger
	 * @See:
	 * @author tangheng
	 * @param obj
	 *            对象
	 * @return 转换后的结果
	 * @date: 2015年4月30日 上午10:19:56
	 */
	public static Integer obj2Integer(Object obj) {
		if (obj == null) {
			return 0;
		}
		String str = String.valueOf(obj).trim();
		if (StringUtil.isNullOrEmpty(str)) {
			return 0;
		}
		return Integer.parseInt(str);
	}

	/**
	 * 说明：声明常量ZERO_VALUE并赋初始值
	 */
	public static final BigDecimal ZERO_VALUE = new BigDecimal(0);
	/**
	 * 说明：声明常量CEM_VALUE并赋初始值
	 */
	public static final BigDecimal CEM_VALUE = BigDecimal.valueOf(100.0);

	/**
	 * 说明：objectToInteger
	 * 
	 * @Title: objectToInteger
	 * @See:
	 * @author tangheng
	 * @param obj
	 *            对象
	 * @return 转换后的结果
	 * @date: 2015年4月30日 上午10:19:56
	 */
	public static Integer objectToInteger(Object obj) {
		if (obj == null) {
			return 0;
		}
		String str = String.valueOf(obj).trim();
		if (isNullOrEmpty(str)) {
			return 0;
		}
		return Integer.parseInt(str);
	}

	/**
	 * 说明：判断BigDecimal值为空返回默认值，否则获取将BigDecimal值转换成Int的值
	 * 
	 * @Title: getValue
	 * @See:
	 * @author tangheng
	 * @param value
	 *            目标对象
	 * @param vlrDefault
	 *            默认值
	 * @return 判断结果
	 * @date: 2015年4月24日 下午12:43:16
	 */
	public static int getValue(BigDecimal value, int vlrDefault) {
		if (value == null || NumberUtil.compareTo(NumberUtil.getValue(0), value) == 0)
			return vlrDefault;
		return value.intValue();
	}

	/**
	 * 说明：判断BigDecimal值为空返回默认值，否则获取将BigDecimal默认值
	 * 
	 * @Title: getValue
	 * @See:
	 * @author tangheng
	 * @param value
	 *            目标对象
	 * @param vlrDefault
	 *            默认值
	 * @return 判断结果
	 * @date: 2015年4月27日 下午6:01:15
	 */
	public static BigDecimal getValue(BigDecimal value, BigDecimal vlrDefault) {
		if (value == null)
			return vlrDefault;
		return value;
	}

	/**
	 * 说明：int转换成BigDecimal
	 * 
	 * @Title: getValue
	 * @See:
	 * @author tangheng
	 * @param value
	 *            int对象
	 * @return 转换后的结果
	 * @date: 2015年4月27日 下午6:04:43
	 */
	public static BigDecimal getValue(int value) {
		return new BigDecimal(value);
	}

	/**
	 * 说明：String对象转换为BigDecimal
	 * 
	 * @Title: getValue
	 * @See:
	 * @author tangheng
	 * @param value
	 *            String对象
	 * @return 判断后转换结果
	 * @date: 2015年4月27日 下午6:09:30
	 */
	public static BigDecimal getValue(String value) {
		if (com.github.pagehelper.util.StringUtil.isEmpty(value)) {
			return new BigDecimal(0);
		}
		try {
			return new BigDecimal(value.replace("\r", "").replace("\n", "").replace(",", "").trim());
		} catch (Exception e) {
			e.printStackTrace();
			return new BigDecimal(0);
		}
	}

	/**
	 * 说明：判断对象值指是否为空，获取相应值
	 * 
	 * @Title: getValue
	 * @See:
	 * @author tangheng
	 * @param value
	 *            判断对象
	 * @return BigDecimal值0
	 * @date: 2015年4月24日 下午1:19:05
	 */
	public static BigDecimal getValue(Object value) {
		if (value == null) {
			return new BigDecimal(0);
		}
		try {
			return getValue(StringUtil.obj2Str(value));
		} catch (Exception e) {
			e.printStackTrace();
			return new BigDecimal(0);
		}
	}

	/**
	 * 说明：判断目标对象若为空，返回常量ZERO_VALUE，否则获得value值
	 * 
	 * @Title: getValueOrZero
	 * @See:
	 * @author tangheng
	 * @param value
	 *            需要判断的对象
	 * @return 结果后的结果
	 * @date: 2015年4月24日 下午1:24:32
	 */
	public static BigDecimal getValueOrZero(BigDecimal value) {
		if (value == null)
			return ZERO_VALUE;
		return value;
	}

	/**
	 * 说明：判断value为空或转换为Int值等于0返回true，否则false
	 * 
	 * @Title: isEmpty
	 * @See:
	 * @author tangheng
	 * @param value
	 *            需要判断的对象
	 * @return boolean结果
	 * @date: 2015年4月24日 下午1:36:15
	 */
	public static boolean isEmpty(BigDecimal value) {
		if (value == null || value.intValue() == 0)
			return true;
		return false;
	}
	
	/**
	 * 说明：判断value为空或转换为Float值等于0返回true，否则false
	 * 
	 * @Title: isEmpty
	 * @See:
	 * @author tangheng
	 * @param value
	 *            需要判断的对象
	 * @return boolean结果
	 * @date: 2015年4月24日 下午1:36:15
	 */
	public static boolean isEmptyByFloat(BigDecimal value) {
		if (value == null || value.floatValue() == 0.00)
			return true;
		return false;
	}

	
	/**
	 * 说明：根据保留小数点位数对value做四舍五入计算
	 * 
	 * @Title: getRounded
	 * @See:
	 * @author tangheng
	 * @param value
	 *            双精度值
	 * @param scale
	 *            要保留小数位数
	 * @return 四舍五入值
	 * @date: 2015年4月24日 下午1:39:05
	 */
	public static BigDecimal getRounded(double value, int scale) {
		return new BigDecimal(value).setScale(scale, BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 说明：取绝对值，并根据保留小数点位数对value做四舍五入
	 * 
	 * @Title: getAbsValue
	 * @See:
	 * @author tangheng
	 * @param value
	 *            取值对象
	 * @param scale
	 *            保留小数位数
	 * @return 判断的结果
	 * @date: 2015年4月24日 下午1:56:47
	 */
	public static BigDecimal getAbsValue(BigDecimal value, int scale) {
		if (NumberUtil.isEmpty(value)) {
			return new BigDecimal(0);
		}
		return new BigDecimal(Math.abs(value.doubleValue())).setScale(scale, BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 说明：给出BigDecimal值，直接刪除多余小数位
	 * 
	 * @Title: truncate
	 * @See:
	 * @author tangheng
	 * @param value
	 *            目标值
	 * @param scale
	 *            保留的小数位数
	 * @return 计算结果
	 * @date: 2015年4月24日 下午2:02:55
	 */
	public static BigDecimal truncate(BigDecimal value, int scale) {
		return value.setScale(scale, BigDecimal.ROUND_DOWN);
	}

	/**
	 * 说明：给出double值，转换为BigDecimal类值后直接删除多余小数位
	 * 
	 * @Title: truncate
	 * @See:
	 * @author tangheng
	 * @param value
	 *            目标值
	 * @param scale
	 *            保留小数位数
	 * @return 四舍五入结果
	 * @date: 2015年4月24日 下午2:06:30
	 */
	public static BigDecimal truncate(double value, int scale) {
		return new BigDecimal(value).setScale(scale, BigDecimal.ROUND_DOWN);
	}

	/**
	 * 说明：将double值转换为BigDecimal类型，并作四舍五入计算得到一个double值
	 * 
	 * @Title: getRoundedDouble
	 * @See:
	 * @author tangheng
	 * @param value
	 *            double值
	 * @param scale
	 *            保留小数位数
	 * @return double值
	 * @date: 2015年4月24日 下午2:17:36
	 */
	public static double getRoundedDouble(double value, int scale) {
		BigDecimal b = new BigDecimal(String.valueOf(value)).setScale(scale, BigDecimal.ROUND_HALF_UP);
		return new Double(b.toString()).doubleValue();
	}

	/**
	 * 说明：转换万 进一法
	 * 
	 * @Title: getBigDecimal
	 * @See:
	 * @author tangheng
	 * @param value
	 *            对象值
	 * @return 判断结果
	 * @date: 2015年4月24日 下午2:19:56
	 */
	public static BigDecimal getBigDecimal(BigDecimal value) {
		if (NumberUtil.isEmpty(value)) {
			return null;
		}
		return NumberUtil.getValue(Math.ceil((new Double(value.toString()).doubleValue()) / 10000));
	}

	/**
	 * 说明：四舍五入计算
	 * 
	 * @Title: getRounded
	 * @See:
	 * @author tangheng
	 * @param value
	 *            计算对象
	 * @param scale
	 *            小数保留位数
	 * @return 计算结果
	 * @date: 2015年4月27日 下午6:27:39
	 */
	public static BigDecimal getRounded(BigDecimal value, int scale) {
		if (value == null) {
			return null;
		}
		return value.setScale(scale, BigDecimal.ROUND_HALF_UP);
	}

	public static BigDecimal getRoundedTY(BigDecimal value) {
		if (value == null) {
			return null;
		}
		return value.setScale(3, BigDecimal.ROUND_HALF_UP);
	}

	public static BigDecimal getRoundedTY(Object value) {
		if (value == null) {
			return null;
		}
		BigDecimal value1 = getValue(value);
		if (value1 == null) {
			return null;
		}
		return value1.setScale(3, BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 说明：取得金额格式【#,##0.00】
	 * 
	 * @Title: toCurrency
	 * @See:
	 * @author tangheng
	 * @param value
	 *            BigDecimal对象
	 * @return 金额格式
	 * @date: 2015年4月27日 下午6:29:37
	 */
	public static String toCurrency(BigDecimal value) {
		return toCurrencyFormat(value, null);
	}

	/**
	 * 说明：取得金额格式 #,##0.00
	 * 
	 * @Title: toCurrencyFormat
	 * @See:
	 * @author tangheng
	 * @param value
	 *            目标值
	 * @param format
	 *            格式
	 * @return 金额格式
	 * @date: 2015年4月24日 下午2:23:14
	 */
	public static String toCurrencyFormat(BigDecimal value, String format) {
		if (NumberUtil.isNullOrEmpty(format)) {
			format = "#,##0.00";
		}
		NumberFormat currencyFormt = new DecimalFormat(format);
		return value == null ? "" : currencyFormt.format(value);
	}

	/**
	 * 说明：判断String format为空
	 * 
	 * @Title: isNullOrEmpty
	 * @See:
	 * @author tangheng
	 * @param format
	 * @return boolean
	 * @date: 2015年5月7日 下午4:23:42
	 */
	private static boolean isNullOrEmpty(String format) {
		return false;
	}

	/**
	 * 说明：去得金额格式#,##0.0000
	 * 
	 * @Title: toCurrencyFour
	 * @See:
	 * @author tangheng
	 * @param value
	 * @return #,##0.0000
	 * @date: 2015年5月7日 下午4:26:54
	 */
	public static String toCurrencyFour(BigDecimal value) {
		return toCurrencyFormat(value, "#,##0.0000");
	}

	/**
	 * 说明：转换数据类型double->BigDecimal
	 * 
	 * @Title: buildFromDouble
	 * @See:
	 * @author tangheng
	 * @param d
	 *            double对象
	 * @return 转换结果
	 * @date: 2015年4月24日 下午2:32:51
	 */
	public static BigDecimal buildFromDouble(double d) {
		int asInt = (int) d;
		BigDecimal result = null;
		if (asInt != d) {
			result = new BigDecimal(String.valueOf(d));
		} else {
			result = new BigDecimal(asInt);
		}
		return result;
	}

	/**
	 * 说明：转换数据类型Number->BigDecimal
	 * 
	 * @Title: buildFromDouble
	 * @See:
	 * @author tangheng
	 * @param d
	 *            数字对象
	 * @return 转换结果
	 * @date: 2015年4月24日 下午2:36:47
	 */
	public static BigDecimal buildFromDouble(Number d) {
		BigDecimal result = null;
		if (d != null) {
			double value = d.doubleValue();
			int asInt = (int) value;
			if (asInt != value) {
				result = new BigDecimal(String.valueOf(value));
			} else {
				result = new BigDecimal(asInt);
			}
		}
		return result;
	}

	/**
	 * 说明：四舍五入乘除计算
	 * 
	 * @Title: porcentagem
	 * @See:
	 * @author tangheng
	 * @param parte
	 * @param todo
	 *            运算顺序
	 * @return 运算结果
	 * @date: 2015年4月27日 下午6:32:39
	 */
	public static BigDecimal porcentagem(BigDecimal parte, BigDecimal todo) {
		MathContext mathCtx = new MathContext(5, RoundingMode.HALF_UP);
		return porcentagem(parte, todo, mathCtx);
	}

	/**
	 * 说明：四舍五入乘除运算
	 * 
	 * @Title: porcentagem
	 * @See:
	 * @author tangheng
	 * @param parte
	 * @param todo
	 *            运算顺序
	 * @param mathCtx
	 *            可以对已选择的精度和舍入模式执行计算
	 * @return 运算结果
	 * @date: 2015年4月27日 下午6:34:27
	 */
	public static BigDecimal porcentagem(BigDecimal parte, BigDecimal todo, MathContext mathCtx) {
		return parte.multiply(CEM_VALUE).divide(todo, mathCtx);
	}

	/**
	 * 说明：传入BigDecimal获得Int类型值
	 * 
	 * @Title: getIntValueByBigDecimal
	 * @See:
	 * @author tangheng
	 * @param value
	 *            BigDecimal对象
	 * @return int值
	 * @date: 2015年4月24日 下午3:02:27
	 */
	public static int getIntValueByBigDecimal(BigDecimal value) {
		int intValue = 0;
		if (value != null) {
			intValue = Integer.valueOf(value.toString());
		}
		return intValue;
	}

	/**
	 * 说明：根据String类值获取BigDecimal
	 * 
	 * @Title: getBigDecimalForString
	 * @See:
	 * @author tangheng
	 * @param value
	 *            String对象
	 * @return 转换后的值
	 * @date: 2015年4月24日 下午3:05:01
	 */
	public static BigDecimal getBigDecimalForString(String value) {
		return new BigDecimal(value);
	}

	/**
	 * 说明：比较两个BigDecimal数据大小
	 * 
	 * @Title: compareTo
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            BigDecimal数值1
	 * @param valueTwo
	 *            BigDecimal数值2
	 * @return 0:两数相等 1:valueOne大于valueTwo -1:valueOne小于valueTwo 9:两数中有null值
	 *         -9:出现异常
	 * @date: 2015年4月24日 下午3:05:58
	 */
	public static int compareTo(BigDecimal valueOne, BigDecimal valueTwo) {
		try {
			valueOne = valueOne == null ? NumberUtil.ZERO_VALUE : valueOne;
			valueTwo = valueTwo == null ? NumberUtil.ZERO_VALUE : valueTwo;
			if (valueOne != null && valueTwo != null) {
				int compare = valueOne.compareTo(valueTwo);
				return compare;
			} else {
				return 9;
			}
		} catch (Exception e) {
			return -9;
		}
	}

	/**
	 * 说明：比较int、BigDecimal两种类型数据
	 * 
	 * @Title: compareTo
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            int数据
	 * @param valueTwo
	 *            BigDecimal数据
	 * @return 0:两数相等 1:valueOne大于valueTwo -1:valueOne小于valueTwo 9:两数中有null值
	 *         -9:出现异常
	 * @date: 2015年4月24日 下午3:09:27
	 */
	public static int compareTo(int valueOne, BigDecimal valueTwo) {
		try {
			if (valueTwo != null) {
				int compare = new BigDecimal(valueOne).compareTo(valueTwo);
				return compare;
			} else {
				return 9;
			}
		} catch (Exception e) {
			return -9;
		}
	}

	/**
	 * 说明：比较String、BigDecimal两种类型数据
	 * 
	 * @Title: compareTo
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            String 数据
	 * @param valueTwo
	 *            BigDecimal数据
	 * @return 0:两数相等 1:valueOne大于valueTwo -1:valueOne小于valueTwo 9:两数中有null值
	 *         -9:出现异常
	 * @date: 2015年4月24日 下午3:13:15
	 */
	public static int compareTo(String valueOne, BigDecimal valueTwo) {
		try {
			if (valueTwo != null) {
				int compare = new BigDecimal(valueOne).compareTo(valueTwo);
				return compare;
			} else {
				return 9;
			}
		} catch (Exception e) {
			return -9;
		}
	}

	/**
	 * 说明：BigDecimal加法运算
	 * 
	 * @Title: add
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @return 根据判断得出相应结果
	 * @date: 2015年4月24日 下午3:15:43
	 */
	public static BigDecimal add(BigDecimal valueOne, BigDecimal valueTwo) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}
		return setDefaultScale(valueOne.add(valueTwo), null);
	}

	public static BigDecimal add(BigDecimal valueOne, BigDecimal valueTwo, int scale) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}
		return setDefaultScale(valueOne.add(valueTwo), scale);
	}
	
	/**
	 * 多个BigDecimal相加
	 * @Desc : []	
	 * @author : zxw_
	 * @Date : 2018年11月9日 下午5:37:37
	 * @param decimals
	 * @return
	 */
	public static BigDecimal adds(BigDecimal... decimals) {
		if( decimals.length > 0 ) {
			for (BigDecimal decimal : decimals) {
				if (null == decimal) {
					decimal = getValue(0);
				}
			}
		}
		BigDecimal zero = BigDecimal.ZERO;
		for (BigDecimal decimal : decimals) {
			if (decimal == null) {
				decimal = getValue(0);
			}
			zero = zero.add(decimal);
		}
		
		return setDefaultScale(zero, null);
	}
	/**
	 * 多个BigDecimal相加
	 * @Desc : []
	 * @author : CWJ
	 * @Date : 2021年12月9日09:23:06
	 * @return
	 */
	public static BigDecimal adds(List<BigDecimal> decimals) {
		BigDecimal zero = BigDecimal.ZERO;
		for (BigDecimal decimal : decimals) {
			if (null == decimal) {
				decimal = getValue(0);
			}
			zero = zero.add(decimal);
		}

		return setDefaultScale(zero, null);
	}
	/**
	 * 多个BigDecimal求平均值
	 * @Desc : []	
	 * @author : CWJ
	 * @Date : 2021年11月19日11:24:20
	 * @param decimals
	 * @return
	 */
	public static BigDecimal average(BigDecimal... decimals) {
		BigDecimal zero = BigDecimal.ZERO;
		if( decimals.length > 0 ) {
			for (BigDecimal decimal : decimals) {
				if (null == decimal) {
					zero=zero.add(getValue(0));
				}else{
					zero = zero.add(decimal);
				}
			}
			zero = NumberUtil.divide(zero, 2, new BigDecimal(decimals.length));
		}
		return setDefaultScale(zero, null);
	}
	/**
	 * 多个BigDecimal求平均值
	 * @Desc : []
	 * @author : CWJ
	 * @Date : 2021年11月19日11:24:20
	 * @param decimals
	 * @return
	 */
	public static BigDecimal average(List<BigDecimal> decimals) {
		BigDecimal zero = BigDecimal.ZERO;
		if( decimals.size() > 0 ) {
			for (BigDecimal decimal : decimals) {
				if (null == decimal) {
					zero=zero.add(getValue(0));
				}else{
					zero = zero.add(decimal);
				}
			}
			zero = NumberUtil.divide(zero, 2, new BigDecimal(decimals.size()));
		}
		return setDefaultScale(zero, null);
	}
	/**
	 * 说明：BigDecimal加法运算
	 * 
	 * @Title: add
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @return 根据判断得出相应结果
	 * @date: 2015年4月24日 下午3:15:43
	 */
	public static BigDecimal add(BigDecimal valueOne, BigDecimal valueTwo, Integer scale) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}
		return setDefaultScale(valueOne.add(valueTwo), scale);
	}

	/**
	 * 说明：BigDecimal减法运算
	 * 
	 * @Title: subtract
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @return 根据判断得出相应结果
	 * @date: 2015年4月24日 下午3:17:56
	 */
	public static BigDecimal subtract(BigDecimal valueOne, BigDecimal valueTwo) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}
		return setDefaultScale(valueOne.subtract(valueTwo), null);
	}

	/**
	 * 说明：BigDecimal减法运算
	 *
	 * @Title: subtract
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @return 根据判断得出相应结果
	 * @date: 2015年4月24日 下午3:17:56
	 */
	public static BigDecimal subtractNew(BigDecimal valueOne, BigDecimal valueTwo) {
		BigDecimal res = null;
		if (valueOne != null && valueTwo != null){
			res =  setDefaultScale(valueOne.subtract(valueTwo),null);
		}
		return res;
	}


	public static BigDecimal subtracts(BigDecimal valueOne, BigDecimal valueTwo,BigDecimal... args) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}

		BigDecimal bigDecimal = valueOne.subtract(valueTwo);

		if (args.length > 0) {
			for (BigDecimal arg : args) {
				bigDecimal = NumberUtil.subtract(bigDecimal,arg);
			}
		}
		return setDefaultScale(bigDecimal, null);
	}

	/**
	 * 说明：BigDecimal减法运算
	 * 
	 * @Title: subtract
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @return 根据判断得出相应结果
	 * @date: 2015年4月24日 下午3:17:56
	 */
	public static BigDecimal subtract(BigDecimal valueOne, BigDecimal valueTwo, int scale) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}
		return setDefaultScale(valueOne.subtract(valueTwo), scale);
	}

	/**
	 * @Description TODO[设置scale默认值]
	 * @author: lishibin
	 * @version V1.0
	 * @date: Apr 26, 2018 5:49:10 PM
	 * @param value
	 * @return
	 */
	public static BigDecimal setDefaultScale(BigDecimal value, Integer scale) {
		if (null == scale) {
			scale = 3;
		}
		if (value.scale() > scale) {
			value = value.setScale(scale, BigDecimal.ROUND_HALF_UP);
		}
		return value;
	}

	/**
	 * 说明：BigDecimal乘法运算
	 * 
	 * @Title: multiply
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @return 根据判断得出相应结果
	 * @date: 2015年4月24日 下午3:19:10
	 */
	public static BigDecimal multiply(BigDecimal valueOne, BigDecimal valueTwo) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}
		return rejection(valueOne.multiply(valueTwo));
	}

	/**
	 * 说明：BigDecimal乘法运算
	 * 
	 * @Title: multiply
	 * @author Cdphantom
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @param scale
	 *            保留小数位数
	 * @return
	 * @date: 2018年4月26日 下午4:26:35
	 */
	public static BigDecimal multiply(BigDecimal valueOne, BigDecimal valueTwo, int scale) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo) {
			valueTwo = getValue(0);
		}
		return rejection(valueOne.multiply(valueTwo), scale);
	}

	/**
	 * 说明：BigDecimal除法运算，取小数点后两位
	 * 
	 * @Title: divide
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param valueTwo
	 *            数值2
	 * @return 得出计算结果
	 * @date: 2015年4月24日 下午3:19:52
	 */
	public static BigDecimal divide(BigDecimal valueOne, BigDecimal valueTwo) {
		return divide(valueOne, 3, valueTwo);
	}

	/**
	 * 说明：BigDecimal除法，根据保留位数作四舍五入计算
	 * 
	 * @Title: divide
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param position
	 *            保留小数位数
	 * @param valueTwo
	 *            数值2
	 * @return 判断后计算的结果
	 * @date: 2015年4月24日 下午3:22:58
	 */
	public static BigDecimal divide(BigDecimal valueOne, int position, BigDecimal valueTwo) {
		if (null == valueOne) {
			valueOne = getValue(0);
		}
		if (null == valueTwo || 0 == NumberUtil.compareTo(valueTwo, NumberUtil.getValue(0))) {
			return ZERO_VALUE;
		}
		return valueOne.divide(valueTwo, position, BigDecimal.ROUND_HALF_UP);
	}

	/**
	 * 说明：BigDecimal除法，根据保留位数作四舍五入计算
	 *
	 * @Title: divide
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param position
	 *            保留小数位数
	 * @param valueTwo
	 *            数值2
	 * @return 判断后计算的结果
	 * @date: 2015年4月24日 下午3:22:58
	 */
	public static BigDecimal divideNew(BigDecimal valueOne, int position, BigDecimal valueTwo) {
		BigDecimal res = null;
		if (valueOne != null && valueTwo != null){
			if (0 == NumberUtil.compareTo(valueTwo, NumberUtil.getValue(0))){
				return ZERO_VALUE;
			}else {
				res = valueOne.divide(valueTwo, position, BigDecimal.ROUND_HALF_UP);
			}
		}
		return res;
	}

	/**
	 * 说明：四舍五入，默认保留小数点后两位
	 * 
	 * @Title: rejection
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @param position
	 *            保留小数位数
	 * @return 计算结果
	 * @date: 2015年4月24日 下午3:28:10
	 */
	public static BigDecimal rejection(BigDecimal valueOne, int position) {
		if (null == valueOne) {
			return getValue(0);
		}
		if (valueOne.scale() > position) {
			valueOne = valueOne.setScale(position, BigDecimal.ROUND_HALF_UP);
		}
		return valueOne;
	}

	/**
	 * 说明：四舍五入，默认保留小数点后两位实现方法
	 * 
	 * @Title: rejection
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数值1
	 * @return 计算结果
	 * @date: 2015年4月24日 下午3:30:15
	 */
	public static BigDecimal rejection(BigDecimal valueOne) {
		return rejection(valueOne, 3);
	}

	/**
	 * 说明：初始化BigDecimal
	 * 
	 * @Title: initBigDecimal
	 * @See:
	 * @author tangheng
	 * @param value
	 *            初始化对象
	 * @return 判断结果
	 * @date: 2015年4月24日 下午3:32:07
	 */
	public static BigDecimal initBigDecimal(BigDecimal value) {
		if (null == value) {
			return NumberUtil.getValue(0);
		} else {
			return value;
		}
	}

	/**
	 * 说明：BigDecimal除法百分比运算
	 * 
	 * @Title: divideUseProportion
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            分子
	 * @param valueTwo
	 *            分母
	 * @return 计算结果
	 * @date: 2015年4月24日 下午3:33:45
	 */
	public static BigDecimal divideUseProportion(BigDecimal valueOne, BigDecimal valueTwo) {
		BigDecimal valueOneTmp_One = multiply(valueOne, getValue(100));
		// BigDecimal valueOneTmp_Two = multiply(valueTwo, getValue(100));
		return divide(valueOneTmp_One, valueTwo);
	}
	public static BigDecimal divideUseProportion(BigDecimal valueOne, BigDecimal valueTwo,Integer position) {
		BigDecimal valueOneTmp_One = multiply(valueOne, getValue(100));
		// BigDecimal valueOneTmp_Two = multiply(valueTwo, getValue(100));
		return divide(valueOneTmp_One, position,valueTwo);
	}

	public static BigDecimal divideUseProportion(BigDecimal valueOne,Integer position ,BigDecimal valueTwo) {
		BigDecimal valueOneTmp_One = multiply(valueOne, getValue(100));
		// BigDecimal valueOneTmp_Two = multiply(valueTwo, getValue(100));
		return divide(valueOneTmp_One, position,valueTwo);
	}

	/**
	 * 说明：BigDecimal百分比乘法运算
	 * 
	 * @Title: multiplyUseProportion
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            被乘数
	 * @param valueTwo
	 *            百分比
	 * @return
	 * @date: 2015年4月24日 下午3:37:15
	 */
	public static BigDecimal multiplyUseProportion(BigDecimal valueOne, BigDecimal valueTwo) {
		BigDecimal valueOneTmp = multiply(valueOne, valueTwo);

		return divide(valueOneTmp, getValue(100));
	}

	/**
	 * 说明：BigDecimal以万作计量的乘法运算
	 * 
	 * @Title: getMultiplyAmount
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            乘数
	 * @return 计算结果
	 * @date: 2015年4月24日 下午3:41:51
	 */
	public static BigDecimal getMultiplyAmount(BigDecimal valueOne) {
		if (valueOne == null) {
			return new BigDecimal(0);
		}
		BigDecimal valueOneTmp = multiply(valueOne, new BigDecimal(10000));

		return valueOneTmp;
	}

	/**
	 * 说明：BigDecimal以万作计量时的乘法运算，要先作判断。BigDecimal为空取默认值
	 * 
	 * @Title: getMultiplyAmount
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            乘数
	 * @param defaultValue
	 *            默认值
	 * @return 判断后的结果
	 * @date: 2015年4月24日 下午3:43:35
	 */
	public static BigDecimal getMultiplyAmount(BigDecimal valueOne, BigDecimal defaultValue) {
		if (valueOne == null) {
			return defaultValue;
		}
		BigDecimal valueOneTmp = multiply(valueOne, new BigDecimal(10000));

		return valueOneTmp;
	}

	/**
	 * 说明：BigDecimal以万作计量时的除法运算，要先作判断，计算结果保留4位小数
	 * 
	 * @Title: getDivideAmount
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            被除数
	 * @return 判断后的结果
	 * @date: 2015年4月24日 下午3:47:23
	 */
	public static BigDecimal getDivideAmount(BigDecimal valueOne) {
		if (valueOne == null) {
			return new BigDecimal(0);
		}
		BigDecimal valueOneTmp = divide(valueOne, 4, new BigDecimal(10000));

		return valueOneTmp;
	}

	/**
	 * 说明：BigDecimal以万作计量时的除法运算，要先作判断，计算结果保留4位小数。BigDecimal为空取默认值
	 * 
	 * @Title: getDivideAmount
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            被除数
	 * @param defaultValue
	 *            默认值
	 * @return 判断后的结果
	 * @date: 2015年4月24日 下午3:49:50
	 */
	public static BigDecimal getDivideAmount(BigDecimal valueOne, BigDecimal defaultValue) {
		if (valueOne == null) {
			return defaultValue;
		}
		BigDecimal valueOneTmp = divide(valueOne, 4, new BigDecimal(10000));

		return valueOneTmp;
	}

	/**
	 * 说明：比较两个Double数据
	 * 
	 * @Title: compareDouble
	 * @See:
	 * @author tangheng
	 * @param valueOne
	 *            数据1
	 * @param valueTwo
	 *            数据2
	 * @return 比较结果
	 * @date: 2015年4月27日 下午7:02:28
	 */
	public static int compareDouble(Double valueOne, Double valueTwo) {
		if (valueOne == null) {
			return -1;
		}
		if (valueTwo == null) {
			return 1;
		}
		return compare(valueOne, valueTwo);

	}// TODO 已修改

	/**
	 * 说明：比较两个Double数据
	 * 
	 * @Title: compare
	 * @See:
	 * @author tangheng
	 * @param lhs
	 * @param rhs
	 * @return 比较值
	 * @date: 2015年5月19日 下午3:55:49
	 */
	public static int compare(double lhs, double rhs) {
		if (lhs < rhs) {
			return -1;
		}
		if (lhs > rhs) {
			return +1;
		}
		long lhsBits = Double.doubleToLongBits(lhs);
		long rhsBits = Double.doubleToLongBits(rhs);
		if (lhsBits == rhsBits) {
			return 0;
		}
		if (lhsBits < rhsBits) {
			return -1;
		} else {
			return +1;
		}
	}
	
	
	/**
	 * obj 保留几位小数
	 * @param obj
	 * @param scale
	 * @return
	 */
	public static BigDecimal getValue(Object obj,int scale) {
		
		BigDecimal value = getValue(obj);
		if (isEmpty(value)) {
			return BigDecimal.ZERO;
		}
		BigDecimal rounded = getRounded(value, scale);
		return rounded;
	}


}
